#include  <iostream>
using  namespace  std;

#define  MVNum  20                                                      //最大顶点数
#define  MAXQSIZE  20                                        //最大队列长度

bool  visited[MVNum];                                                      //访问标志数组，其初值为"false"

//-----图的邻接矩阵存储表示-----
struct  Graph{
	int  vexs[MVNum];                                        //顶点表
	int  arcs[MVNum][MVNum];                            //邻接矩阵
	int  vexnum,arcnum;                                                //图的当前点数和边数
};

//----队列的定义及操作--------
struct  sqQueue{
	int    *base;                                                        //初始化的动态分配存储空间
	int  front;                                                                //头指针，若队列不空，指向队头元素
	int  rear;                                                                //尾指针，若队列不空，指向队尾元素的下一个位置
};

void  InitQueue(sqQueue  &Q){
	//构造一个空队列Q
	Q.base  =  new  int[MAXQSIZE];
	if(!Q.base)          cout<<"存储分配失败";                                //存储分配失败
	Q.front  =  Q.rear  =  0;
}//InitQueue

void  EnQueue(sqQueue  &Q,  int  e){
	//插入元素e为Q的新的队尾元素
	if((Q.rear  +  1)  %  MAXQSIZE  ==  Q.front)
		return;
	Q.base[Q.rear]  =  e;
	Q.rear  =  (Q.rear  +  1)  %  MAXQSIZE;
}//EnQueue

bool  QueueEmpty(sqQueue  Q){
	//判断是否为空队
	if(Q.rear  ==  Q.front)
		return  true;
	return  false;
}//QueueEmpty

void  DeQueue(sqQueue  &Q,  int  &u){
	//队头元素出队并置为u
	u  =  Q.base[Q.front];
	Q.front  =  (Q.front  +  1)  %  MAXQSIZE;
}//DeQueue
//--------------------------------------------------

int  LocateVex(Graph  G  ,  int  v){
	//确定点v在G中的位置
	for(int  i  =  0;  i  <  G.vexnum;  ++i)
		if(G.vexs[i]  ==  v)
			return  i;
	return  -1;
}//LocateVex

void  CreateUDN(Graph  &G){
	//采用邻接矩阵表示法，创建无向网G
	int  i  ,  j  ,  k;
	//输入总顶点数，总边数，以空格隔开
	cin  >>  G.vexnum  >>  G.arcnum;                                                        //输入总顶点数，总边数
	//输入点的名称，如a
	for(i  =  0;  i  <  G.vexnum;  ++i){
		//请输入各个点的名称
		cin  >>  G.vexs[i];                                                                        //依次输入点的信息
	}
	for(i  =  0;  i  <  G.vexnum;  ++i)                                                        //初始化邻接矩阵，边的权值均置为极大值MaxInt
		for(j  =  0;  j  <  G.vexnum;  ++j)
			G.arcs[i][j]  =  0;
	//输入边依附的顶点，如a  b
	for(k  =  0;  k  <  G.arcnum;++k){                                                        //构造邻接矩阵
		int  v1  ,  v2;
		//输入各个边依附的顶点
		cin  >>  v1  >>  v2;                                                                        //输入一条边依附的顶点
		i  =  LocateVex(G,  v1);    j  =  LocateVex(G,  v2);                //确定v1和v2在G中的位置，即顶点数组的下标
		G.arcs[i][j]  =  1;                                                                        //边<v1,  v2>的权值置为w
		G.arcs[j][i]  =  G.arcs[i][j];                                                //置<v1,  v2>的对称边<v2,  v1>的权值为w
	}//for
}//CreateUDN

int  FirstAdjVex(Graph  G  ,  int  v){
	//返回v的第一个邻接点
	int  i;
	for(i  =  0  ;  i  <  G.vexnum  ;  ++i){
		if(G.arcs[v][i]  ==  1  &&  visited[i]  ==  false)
			return  i;
	}
	return  -1;
}//FirstAdjVex

int  NextAdjVex(Graph  G  ,  int  v  ,  int  w){
	//返回v相对于w的下一个邻接点
	int  i;
	for(i  =  w+1  ;  i  <  G.vexnum  ;  ++i){
		if(G.arcs[v][i]  ==  1  &&  visited[i]  ==  false)
			return  i;
	}
	return  -1;
}//NextAdjVex

void BFS(Graph g,int i){
	
}

int  main(){
	
	Graph  G;
	CreateUDN(G);
	//输入遍历连通图的起始点
	int  c;
	cin  >>  c;
	
	int  i;
	for(i  =  0  ;  i  <  G.vexnum  ;  ++i){
		if(c  ==  G.vexs[i])
			break;
	}
	
	if  (i  >=  G.vexnum)  cout<<"error!";
	//广度优先搜索遍历连通图结果
	BFS(G  ,  i);
	
	cout  <<endl;
	return  0;
}//main
